package com.changgou.goods.service.impl;

import com.changgou.goods.dao.CategoryMapper;
import com.changgou.goods.dao.SpecMapper;
import com.changgou.goods.dao.TemplateMapper;
import com.changgou.goods.pojo.Category;
import com.changgou.goods.pojo.Spec;
import com.changgou.goods.pojo.Template;
import com.changgou.goods.service.SpecService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

/**
 * @Author seafwg
 * @Date 2021/11/29 10:19 下午
 * @Version 1.0
 * @description xxx
 */
@Service
public class SpecServiceImpl implements SpecService {

    @Autowired
    private SpecMapper specMapper;

    @Autowired
    private TemplateMapper templateMapper;

    @Autowired
    private CategoryMapper categoryMapper;
    /**
     * 根据分类ID查询规格参数信息
     * @param cid
     * @return
     */
    @Override
    public List<Spec> findSpecByCategoryId(Integer cid) {
        // 根据分类ID查询分类信息
        Category category = categoryMapper.selectByPrimaryKey(cid);
        // 生成一个规格对象，给规格对象设置模板id，规格mapper调用查询
        // 给一个空对象设置主键，调用查询，该主键作为查询条件查询
        Spec spec = new Spec();
        spec.setTemplateId(category.getTemplateId());
        List<Spec> specList = specMapper.select(spec);
        return specList;
    }

    /**
     * 新增规格：增删要修改模板管理中的规格数量
     * @param spec
     * @return
     */
    @Override
    public int add(Spec spec) {
        // 新增
        int insert = specMapper.insert(spec);
        // 修改模板中的规格数量
        updateTemplateSpecNum(spec, 1);
        return insert;
    }

    /**
     * 根据ID删除规格：要修改模板中规格的数量
     * @param id
     * @return
     */
    @Override
    public int delete(Integer id) {
        // 根据id查询出spec对象
        Spec spec = specMapper.selectByPrimaryKey(id);
        updateTemplateSpecNum(spec, -1);

        // 删除：
        int delete = specMapper.deleteByPrimaryKey(id);
        return delete;
    }

    /**
     * 更新规格：
     * @param spec
     */
    @Override
    public void update(Spec spec) {
        specMapper.updateByPrimaryKeySelective(spec);
    }

    /**
     * 根据ID查询规格：
     * @param id
     * @return
     */
    @Override
    public Spec findById(Integer id) {
        Spec spec = specMapper.selectByPrimaryKey(id);
        return spec;
    }

    /**
     * 查询所有规格：
     * @return
     */
    @Override
    public List<Spec> findAll() {
        return specMapper.selectAll();
    }

    /**
     * 多条件查询：根据规格信息多条件查询
     * @param spec
     * @return
     */
    @Override
    public List<Spec> findList(Spec spec) {
        // 调用创建条件器生成查询条件
        Example example = createExample(spec);
        List<Spec> list = specMapper.selectByExample(example);
        return list;
    }

    /**
     * 分页查询
     * @param pageSize
     * @param pageNum
     * @return
     */
    @Override
    public PageInfo<Spec> findPage(Integer pageSize, Integer pageNum) {
        // 使用分页插件
        PageHelper.startPage(pageSize, pageSize);
        // 查询所有
        List<Spec> specList = specMapper.selectAll();
        // 根据查询的数据生成PageInfo对象
        PageInfo<Spec> specPageInfo = new PageInfo<>(specList);
        return specPageInfo;
    }

    /**
     * 多条件分页查询：
     * @param spec
     * @param pageSize
     * @param pageNum
     * @return
     */
    @Override
    public PageInfo<Spec> findPageList(Spec spec, Integer pageSize, Integer pageNum) {
        // 分页：
        PageHelper.startPage(pageSize, pageNum);
        // 生成查询对象
        Example example = createExample(spec);
        // 查询
        List<Spec> specList = specMapper.selectByExample(example);
        // 组装分页
        PageInfo<Spec> specPageInfo = new PageInfo<>(specList);
        return specPageInfo;
    }

    /**
     * 修改模板管理里面的specNum,规格数量：add +1,delete +1
     * @param spec
     * @param num
     */
    public void updateTemplateSpecNum(Spec spec, Integer num) {
        // 根据spec的id查询template对象
        Template template = templateMapper.selectByPrimaryKey(spec.getTemplateId());
        // 设置specNum模板中关联的规格个数
        template.setSpecNum(template.getSpecNum() + num);
        // 更新模板
        templateMapper.updateByPrimaryKeySelective(template);
    }

    /**
     * 创建查询条件
     * @param spec
     * @return
     */
    public Example createExample(Spec spec) {
        // 1.生成查询对象
        Example example = new Example(Spec.class);
        // 2.创建条件构造器
        Example.Criteria criteria = example.createCriteria();
        // 3.添加查询条件
        if (spec != null) {
            // id
            if(!StringUtils.isEmpty(spec.getId())) {
                criteria.andEqualTo("id", spec.getId());
            }
            // name - 名称
            if(!StringUtils.isEmpty(spec.getName())) {
                criteria.andLike("name", "%" + spec.getName() + "%");
            }
            // options - 规格选项
            if(!StringUtils.isEmpty(spec.getOptions())) {
                criteria.andEqualTo("options", spec.getOptions());
            }
            // sep - 排序
            if(!StringUtils.isEmpty(spec.getSeq())) {
                criteria.andEqualTo("sep", spec.getSeq());
            }
            // templateId - 模板id
            if(!StringUtils.isEmpty(spec.getTemplateId())) {
                criteria.andEqualTo("templateId", spec.getTemplateId());
            }
        }
        return example;
    }
}
